home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / lang_c / bisonpcb / tgram.c < prev    next >
C/C++ Source or Header  |  1987-09-17  |  11KB  |  477 lines
  1.  
  2. /*  A Bison parser, made from tgram.y  */
  3.  
  4. #define    TERM    258
  5. #define    TTERM    3
  6. #define    UMINUS    259
  7. #define    TUMINUS    11
  8.  
  9. #include "tgram.att"
  10. #include <stdio.h>
  11.  
  12.  
  13.  
  14. #define    YYFINAL        20
  15. #define    YYFLAG        -32768
  16. #define    YYNTBASE    12
  17.  
  18. #define YYTRANSLATE(x) (yytranslate[x])
  19.  
  20. static char yytranslate[] = {     0,
  21.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  22.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  23.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  24.      2,     2,     2,     2,     2,     2,     2,     2,     2,     4,
  25.      5,     9,     7,     2,     8,     2,     2,     2,     2,     2,
  26.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  27.      6,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  28.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  29.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  30.      2,    10,     2,     2,     2,     2,     2,     2,     2,     2,
  31.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  32.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  33.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  34.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  35.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  36.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  37.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  38.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  39.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  40.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  41.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  42.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  43.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  44.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  45.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  46.      2,     2,     2,     2,     2,     1,     2,     3,    11
  47. };
  48.  
  49. static short yyprhs[] = {     0,
  50.      0,     4,     8,    12,    16,    17,    22,    25,    27
  51. };
  52.  
  53. static short yyrhs[] = {    12,
  54.      7,    12,     0,    12,     8,    12,     0,    12,     9,    12,
  55.      0,    12,    10,    12,     0,     0,     4,    13,    12,     5,
  56.      0,     8,    12,     0,     3,     0,    12,     6,    12,     0
  57. };
  58.  
  59. static short yystos[] = {     0,
  60.      3,     4,     8,    12,    13,    12,     6,     7,     8,     9,
  61.     10,    12,    12,    12,    12,    12,    12,     5,     0,     0
  62. };
  63.  
  64. static short yyrline[] = {     0,
  65.     14,    15,    16,    17,    18,    18,    19,    20,    21
  66. };
  67.  
  68. static char * yytname[] = {     0,
  69. "error","$illegal.","TERM","'('","')'","'='","'+'","'-'","'*'","'\\\\'",
  70. "UMINUS","expr"
  71. };
  72.  
  73. static short yyr1[] = {     0,
  74.     12,    12,    12,    12,    13,    12,    12,    12,    12
  75. };
  76.  
  77. static short yyr2[] = {     0,
  78.      3,     3,     3,     3,     0,     4,     2,     1,     3
  79. };
  80.  
  81. static short yydefact[] = {     0,
  82.      8,     5,     0,     0,     0,     7,     0,     0,     0,     0,
  83.      0,     0,     9,     1,     2,     3,     4,     6,     0,     0
  84. };
  85.  
  86. static short yydefgoto[] = {     4,
  87.      5
  88. };
  89.  
  90. static short yypact[] = {    23,
  91. -32768,-32768,    23,     0,    23,-32768,    23,    23,    23,    23,
  92.     23,    15,    -5,    19,-32768,-32768,-32768,-32768,    12,-32768
  93. };
  94.  
  95. static short yypgoto[] = {     8,
  96. -32768
  97. };
  98.  
  99.  
  100. #define    YYLAST        31
  101.  
  102.  
  103. static short yytable[] = {    19,
  104.      7,     8,     9,    10,    11,     7,     8,     9,    10,    11,
  105.      6,    20,    12,     0,    13,    14,    15,    16,    17,    18,
  106.      7,     8,     9,    10,    11,     1,     2,    10,    11,     0,
  107.      3
  108. };
  109.  
  110. static short yycheck[] = {     0,
  111.      6,     7,     8,     9,    10,     6,     7,     8,     9,    10,
  112.      3,     0,     5,    -1,     7,     8,     9,    10,    11,     5,
  113.      6,     7,     8,     9,    10,     3,     4,     9,    10,    -1,
  114.      8
  115. };
  116. #define YYPURE 1
  117.  
  118.  
  119. extern int timeclock;
  120.  
  121.  
  122. int yyerror;        /*  Yyerror and yycost are set by guards.    */
  123. int yycost;        /*  If yyerror is set to a nonzero value by a    */
  124.             /*  guard, the reduction with which the guard    */
  125.             /*  is associated is not performed, and the    */
  126.             /*  error recovery mechanism is invoked.    */
  127.             /*  Yycost indicates the cost of performing    */
  128.             /*  the reduction given the attributes of the    */
  129.             /*  symbols.                    */
  130.  
  131.  
  132. #define    YYACCEPT    return (0)
  133. #define    YYABORT        return (1)
  134.  
  135.  
  136. /*  YYMAXDEPTH indicates the size of the parser's state and value    */
  137. /*  stacks.                                */
  138.  
  139. #ifndef    YYMAXDEPTH
  140. #define    YYMAXDEPTH    500
  141. #endif
  142.  
  143. /*  YYMAXRULES must be at least as large as the number of rules that    */
  144. /*  could be placed in the rule queue.  That number could be determined    */
  145. /*  from the grammar and the size of the stack, but, as yet, it is not.    */
  146.  
  147. #ifndef    YYMAXRULES
  148. #define    YYMAXRULES    100
  149. #endif
  150.  
  151. #ifndef    YYMAXBACKUP
  152. #define YYMAXBACKUP    100
  153. #endif
  154.  
  155.  
  156. short    yyss[YYMAXDEPTH];    /*  the state stack            */
  157. YYSTYPE    yyvs[YYMAXDEPTH];    /*  the semantic value stack        */
  158. YYLTYPE yyls[YYMAXDEPTH];    /*  the location stack            */
  159. short    yyrq[YYMAXRULES];    /*  the rule queue            */
  160. int    yychar;            /*  the lookahead symbol        */
  161.  
  162. YYSTYPE    yylval;            /*  the semantic value of the        */
  163.                 /*  lookahead symbol            */
  164.  
  165. YYSTYPE yytval;            /*  the semantic value for the state    */
  166.                 /*  at the top of the state stack.    */
  167.  
  168. YYSTYPE yyval;            /*  the variable used to return        */
  169.                 /*  semantic values from the action    */
  170.                 /*  routines                */
  171.  
  172. YYLTYPE yylloc;        /*  location data for the lookahead    */
  173.                 /*  symbol                */
  174.  
  175. YYLTYPE yytloc;        /*  location data for the state at the    */
  176.                 /*  top of the state stack        */
  177.  
  178.  
  179. int    yynunlexed;
  180. short    yyunchar[YYMAXBACKUP];
  181. YYSTYPE    yyunval[YYMAXBACKUP];
  182. YYLTYPE yyunloc[YYMAXBACKUP];
  183.  
  184. short *yygssp;            /*  a pointer to the top of the state    */
  185.                 /*  stack; only set during error    */
  186.                 /*  recovery.                */
  187.  
  188. YYSTYPE *yygvsp;        /*  a pointer to the top of the value    */
  189.                 /*  stack; only set during error    */
  190.                 /*  recovery.                */
  191.  
  192. YYLTYPE *yyglsp;        /*  a pointer to the top of the        */
  193.                 /*  location stack; only set during    */
  194.                 /*  error recovery.            */
  195.  
  196.  
  197. /*  Yyget is an interface between the parser and the lexical analyzer.    */
  198. /*  It is costly to provide such an interface, but it avoids requiring    */
  199. /*  the lexical analyzer to be able to back up the scan.        */
  200.  
  201. yyget()
  202. {
  203.   if (yynunlexed > 0)
  204.     {
  205.       yynunlexed--;
  206.       yychar = yyunchar[yynunlexed];
  207.       yylval = yyunval[yynunlexed];
  208.       yylloc = yyunloc[yynunlexed];
  209.     }
  210.   else if (yychar <= 0)
  211.     yychar = 0;
  212.   else
  213.     {
  214.       yychar = yylex();
  215.       if (yychar < 0)
  216.     yychar = 0;
  217.       else yychar = YYTRANSLATE(yychar);
  218.     }
  219. }
  220.  
  221.  
  222.  
  223. yyunlex(chr, val, loc)
  224. int chr;
  225. YYSTYPE val;
  226. YYLTYPE loc;
  227. {
  228.   yyunchar[yynunlexed] = chr;
  229.   yyunval[yynunlexed] = val;
  230.   yyunloc[yynunlexed] = loc;
  231.   yynunlexed++;
  232. }
  233.  
  234.  
  235.  
  236. yyrestore(first, last)
  237. register short *first;
  238. register short *last;
  239. {
  240.   register short *ssp;
  241.   register short *rp;
  242.   register int symbol;
  243.   register int state;
  244.   register int tvalsaved;
  245.  
  246.   ssp = yygssp;
  247.   yyunlex(yychar, yylval, yylloc);
  248.  
  249.   tvalsaved = 0;
  250.   while (first != last)
  251.     {
  252.       symbol = yystos[*ssp];
  253.       if (symbol < YYNTBASE)
  254.     {
  255.       yyunlex(symbol, yytval, yytloc);
  256.       tvalsaved = 1;
  257.       ssp--;
  258.     }
  259.  
  260.       ssp--;
  261.  
  262.       if (first == yyrq)
  263.     first = yyrq + YYMAXRULES;
  264.  
  265.       first--;
  266.  
  267.       for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
  268.     {
  269.       if (symbol < YYNTBASE)
  270.         state = yytable[yypact[*ssp] + symbol];
  271.       else
  272.         {
  273.           state = yypgoto[symbol - YYNTBASE] + *ssp;
  274.  
  275.           if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
  276.         state = yytable[state];
  277.           else
  278.         state = yydefgoto[symbol - YYNTBASE];
  279.         }
  280.  
  281.       *++ssp = state;
  282.     }
  283.     }
  284.  
  285.   if ( ! tvalsaved && ssp > yyss)
  286.     {
  287.       yyunlex(yystos[*ssp], yytval, yytloc);
  288.       ssp--;
  289.     }
  290.  
  291.   yygssp = ssp;
  292. }
  293.  
  294.  
  295.  
  296. int
  297. yyparse()
  298. {
  299.   register int yystate;
  300.   register int yyn;
  301.   register short *yyssp;
  302.   register short *yyrq0;
  303.   register short *yyptr;
  304.   register YYSTYPE *yyvsp;
  305.  
  306.   int yylen;
  307.   YYLTYPE *yylsp;
  308.   short *yyrq1;
  309.   short *yyrq2;
  310.  
  311.   yystate = 0;
  312.   yyssp = yyss - 1;
  313.   yyvsp = yyvs - 1;
  314.   yylsp = yyls - 1;
  315.   yyrq0 = yyrq;
  316.   yyrq1 = yyrq0;
  317.   yyrq2 = yyrq0;
  318.  
  319.   yychar = yylex();
  320.   if (yychar < 0)
  321.     yychar = 0;
  322.   else yychar = YYTRANSLATE(yychar);
  323.  
  324. yynewstate:
  325.  
  326.   if (yyssp >= yyss + YYMAXDEPTH - 1)
  327.     {
  328.       yyabort("Parser Stack Overflow");
  329.       YYABORT;
  330.     }
  331.  
  332.   *++yyssp = yystate;
  333.  
  334. yyresume:
  335.  
  336.   yyn = yypact[yystate];
  337.   if (yyn == YYFLAG)
  338.     goto yydefault;
  339.  
  340.   yyn += yychar;
  341.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
  342.     goto yydefault;
  343.  
  344.   yyn = yytable[yyn];
  345.   if (yyn < 0)
  346.     {
  347.       yyn = -yyn;
  348.       goto yyreduce;
  349.     }
  350.   else if (yyn == 0)
  351.     goto yyerrlab;
  352.  
  353.   yystate = yyn;
  354.  
  355.   yyptr = yyrq2;
  356.   while (yyptr != yyrq1)
  357.     {
  358.       yyn = *yyptr++;
  359.       yylen = yyr2[yyn];
  360.       yyvsp -= yylen;
  361.       yylsp -= yylen;
  362.  
  363.       yyguard(yyn, yyvsp, yylsp);
  364.       if (yyerror)
  365.     goto yysemerr;
  366.  
  367.       yyaction(yyn, yyvsp, yylsp);
  368.       *++yyvsp = yyval;
  369.  
  370.       yylsp++;
  371.       if (yylen == 0)
  372.     {
  373.       yylsp->timestamp = timeclock;
  374.       yylsp->first_line = yytloc.first_line;
  375.       yylsp->first_column = yytloc.first_column;
  376.       yylsp->last_line = (yylsp-1)->last_line;
  377.       yylsp->last_column = (yylsp-1)->last_column;
  378.       yylsp->text = 0;
  379.     }
  380.       else
  381.     {
  382.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  383.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  384.     }
  385.       
  386.       if (yyptr == yyrq + YYMAXRULES)
  387.         yyptr = yyrq;
  388.     }
  389.  
  390.   if (yystate == YYFINAL)
  391.     YYACCEPT;
  392.  
  393.   yyrq2 = yyptr;
  394.   yyrq1 = yyrq0;
  395.  
  396.   *++yyvsp = yytval;
  397.   *++yylsp = yytloc;
  398.   yytval = yylval;
  399.   yytloc = yylloc;
  400.   yyget();
  401.  
  402.   goto yynewstate;
  403.  
  404. yydefault:
  405.  
  406.   yyn = yydefact[yystate];
  407.   if (yyn == 0)
  408.     goto yyerrlab;
  409.  
  410. yyreduce:
  411.  
  412.   *yyrq0++ = yyn;
  413.  
  414.   if (yyrq0 == yyrq + YYMAXRULES)
  415.     yyrq0 = yyrq;
  416.  
  417.   if (yyrq0 == yyrq2)
  418.     {
  419.       yyabort("Parser Rule Queue Overflow");
  420.       YYABORT;
  421.     }
  422.  
  423.   yyssp -= yyr2[yyn];
  424.   yyn = yyr1[yyn];
  425.  
  426.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  427.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  428.     yystate = yytable[yystate];
  429.   else
  430.     yystate = yydefgoto[yyn - YYNTBASE];
  431.  
  432.   goto yynewstate;
  433.  
  434. yysemerr:
  435.   *--yyptr = yyn;
  436.   yyrq2 = yyptr;
  437.   yyvsp += yyr2[yyn];
  438.  
  439. yyerrlab:
  440.  
  441.   yygssp = yyssp;
  442.   yygvsp = yyvsp;
  443.   yyglsp = yylsp;
  444.   yyrestore(yyrq0, yyrq2);
  445.   yyrecover();
  446.   yystate = *yygssp;
  447.   yyssp = yygssp;
  448.   yyvsp = yygvsp;
  449.   yyrq0 = yyrq;
  450.   yyrq1 = yyrq0;
  451.   yyrq2 = yyrq0;
  452.   goto yyresume;
  453. }
  454.  
  455. /* Action file follows: */
  456. yyaction(n, yyvsp, yylsp)
  457. register int n;
  458. register YYSTYPE *yyvsp;
  459. register YYLTYPE *yylsp;
  460.     {
  461.     switch (n)
  462.         {
  463. case 5:
  464. #line 18 "tgram.y"
  465. { yyval = -1; ;
  466.     break;}
  467. case 6:
  468. #line 18 "tgram.y"
  469. {yyval = yyvsp[4]; ;
  470.     break;}
  471.     }
  472. }
  473.  
  474. /* End of Action file */
  475. #line 24 "tgram.y"
  476.  
  477.